package net.sf.tomcatmanager;
import java.io.File;
import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
import java.util.prefs.Preferences;
/**
* This class represents the application's model, containing a shared state.
*
* @author Martin Edling Andersson, Leonard van Driel
*/
public class Model {
private transient Logger logger = Logger.getLogger(Model.class.toString());
/**
* The states a server can be in. NONE - No information of the server
* available yet. STOPPED - The server is not running. STARTING - The server
* is not running, but we're trying to start running it. STARTING_FAILED -
* The server is not running, we failed to start running it. STARTED - The
* server is running. STOPPING - The server is running, but we're trying to
* stop running it. STOPPING_FAILED - The server is running, we failed to
* stop running it.
*/
public enum ServerState {
NONE, STOPPED, STARTING, STARTING_FAILED, STARTED, STOPPING, STOPPING_FAILED
}
private final static String JAVA_HOME_VARIABLE = "JAVA_HOME";
private final static String TOMCAT_LOCATION_VARIABLE = "CATALINA_HOME";
// GUI configurable preferences
private final static String KEY_TOMCAT_LOCATION_PATH = "tomcat location path";
private final static String DEF_TOMCAT_LOCATION_PATH = System.getProperty("user.home") + "/Library/ApacheTomcat";
private final static String KEY_JAVA_HOME_PATH = "java home path";
private final static String DEF_JAVA_HOME_PATH = "/Library/Java/Home";
private final static String KEY_SLEEP_TIME = "sleep time";
private final static int DEF_SLEEP_TIME = 4000;
private final static String KEY_TIMEOUT_TIME = "timeout time";
private final static int DEF_TIMEOUT_TIME = 10000;
private final static String KEY_LOG_PATH = "log file";
private final static String DEF_LOG_PATH = System.getProperty("user.home") + "/Library/Logs/" + About.NAME_NO_SPACE;
// non-GUI configurable preferences
private final static String KEY_SERVER_URL = "server url";
private final static String DEF_SERVER_URL = "localhost";
private final static String KEY_SERVER_PORT = "server port";
private final static int DEF_SERVER_PORT = 8080;
private final static String KEY_CATALINA_SCRIPT_FILE = "catalina script file";
private final static String DEF_CATALINA_SCRIPT_FILE = "bin/catalina.sh";
private final static String KEY_STARTUP_SCRIPT_PARAM = "startup parameter";
private final static String DEF_STARTUP_SCRIPT_PARAM = "run";
private final static String KEY_SHUTDOWN_SCRIPT_PARAM = "shutdown parameter";
private final static String DEF_SHUTDOWN_SCRIPT_PARAM = "stop";
private final static String KEY_JAVA_EXECUTABLE_FILE = "java executable file";
private final static String DEF_JAVA_EXECUTABLE_FILE = "/bin/java";
// non-GUI configurable preferences cache
private String catalinaScriptFile;
private String startupScriptParam;
private String shutdownScriptParam;
private String javaExecutableFile;
private String serverUrl;
private int serverPort;
// model-view-controller
private Controller controller;
/**
* The server state this model is assuming.
*/
private ServerState serverState = ServerState.NONE;
/**
* The last time that the server state was changed.
*/
private long lastStateChangeTime;
/**
* The handler used for logging to a file. This attribute's value is removed
* from the handler list before adding a new file log handler.
*/
private FileHandler logFileHandler;
/**
* Instantiates a new model.
*/
public Model() {
logger.setLevel(TomcatManagerGui.DEFAULT_LOG_LEVEL);
}
/**
* Caches this class' non-GUI configurable preferences into class
* attributes.
*/
public void loadFromPreferences() {
Preferences preferences = controller.getPreferences();
catalinaScriptFile = preferences.get(KEY_CATALINA_SCRIPT_FILE, DEF_CATALINA_SCRIPT_FILE);
startupScriptParam = preferences.get(KEY_STARTUP_SCRIPT_PARAM, DEF_STARTUP_SCRIPT_PARAM);
shutdownScriptParam = preferences.get(KEY_SHUTDOWN_SCRIPT_PARAM, DEF_SHUTDOWN_SCRIPT_PARAM);
javaExecutableFile = preferences.get(KEY_JAVA_EXECUTABLE_FILE, DEF_JAVA_EXECUTABLE_FILE);
serverPort = preferences.getInt(KEY_SERVER_PORT, DEF_SERVER_PORT);
serverUrl = preferences.get(KEY_SERVER_URL, DEF_SERVER_URL);
}
public void postInit() {
loadFromPreferences();
controller.setServerState(serverState);
}
/**
* Stores this class' preferences.
*/
public void saveToPreferences() {
}
/**
* Replaces the file log handler by checking and creating the log file,
* removing the existing handler and creating a new one.
*/
public void updateLogPath() {
// check and create log file
String logPathString = getLogPath();
if (logPathString.length() == 0) {
return;
}
File folderPath = new File(logPathString);
String filePath = (folderPath.getAbsolutePath() + "/" + About.NAME_NO_SPACE + ".log").replace("//", "/");
File fileFile = new File(filePath);
if (!fileFile.exists()) {
try {
folderPath.mkdirs();
fileFile.createNewFile();
} catch (IOException e) {
logger.warning("Unable to create log file '" + fileFile + "': " + e);
e.printStackTrace();
return;
}
}
// add log file handler
try {
FileHandler newHandler = new FileHandler(filePath, 1000, 1, true);
SimpleFormatter logFormatter = new SimpleFormatter();
newHandler.setFormatter(logFormatter);
Logger.getLogger("").addHandler(newHandler);
if (logFileHandler != null) {
Logger.getLogger("").removeHandler(logFileHandler);
}
logFileHandler = newHandler;
logger.info("Set log file to: " + filePath);
} catch (SecurityException e) {
logger.warning("Unable to access log file '" + fileFile + "': " + e);
} catch (IOException e) {
logger.warning("Unable to access log file '" + fileFile + "': " + e);
}
}
public void setController(Controller controller) {
this.controller = controller;
}
/**
* Directly set this model's server state.
*
* @param serverState
* The new state.
*/
public void setServerState(ServerState serverState) {
if (this.serverState != serverState) {
this.serverState = serverState;
lastStateChangeTime = System.currentTimeMillis();
}
}
/**
* Indirectly set this model's server state by providing the whether the
* server is running.
*
* @param running
* True iff the server is running.
*/
public void setServerStarted(boolean running) {
if (running) {
if (serverState != ServerState.STOPPING && serverState != ServerState.STOPPING_FAILED) {
controller.setServerState(ServerState.STARTED);
} else if (serverState == ServerState.STOPPING
&& lastStateChangeTime + getTimeoutTime() < System.currentTimeMillis()) {
controller.setServerState(ServerState.STOPPING_FAILED);
}
} else {
if (serverState != ServerState.STARTING && serverState != ServerState.STARTING_FAILED) {
controller.setServerState(ServerState.STOPPED);
} else if (serverState == ServerState.STARTING
&& lastStateChangeTime + getTimeoutTime() < System.currentTimeMillis()) {
controller.setServerState(ServerState.STARTING_FAILED);
}
}
}
public String getTomcatLocationPath() {
return controller.getPreferences().get(KEY_TOMCAT_LOCATION_PATH, DEF_TOMCAT_LOCATION_PATH);
}
public void setTomcatLocationPath(String path) {
controller.getPreferences().put(KEY_TOMCAT_LOCATION_PATH, path);
}
public String getJavaHomePath() {
return controller.getPreferences().get(KEY_JAVA_HOME_PATH, DEF_JAVA_HOME_PATH);
}
public void setJavaHomePath(String path) {
controller.getPreferences().put(KEY_JAVA_HOME_PATH, path);
}
public int getSleepTime() {
return controller.getPreferences().getInt(KEY_SLEEP_TIME, DEF_SLEEP_TIME);
}
public void setSleepTime(int time) {
controller.getPreferences().putInt(KEY_SLEEP_TIME, time);
}
public int getTimeoutTime() {
return controller.getPreferences().getInt(KEY_TIMEOUT_TIME, DEF_TIMEOUT_TIME);
}
public void setTimeoutTime(int time) {
controller.getPreferences().putInt(KEY_TIMEOUT_TIME, time);
}
public String getLogPath() {
return controller.getPreferences().get(KEY_LOG_PATH, DEF_LOG_PATH);
}
public void setLogPath(String path) {
boolean changed = !path.equals(getLogPath());
controller.getPreferences().put(KEY_LOG_PATH, path);
if (changed) {
updateLogPath();
}
}
public String getJavaHomeEnvironmentVariable() {
return JAVA_HOME_VARIABLE;
}
public String getTomcatLocationEnvironmentVariable() {
return TOMCAT_LOCATION_VARIABLE;
}
public ServerState getServerState() {
return serverState;
}
public boolean isServerStartedOrAboutTo() {
switch (serverState) {
case STARTED:
case STARTING:
case STOPPING_FAILED:
return true;
default:
return false;
}
}
public boolean isServerStoppedOrAboutTo() {
switch (serverState) {
case STOPPED:
case STOPPING:
case STARTING_FAILED:
return true;
default:
return false;
}
}
public String getCatalinaScriptFile() {
return catalinaScriptFile;
}
public String getStartupScriptParam() {
return startupScriptParam;
}
public String getShutdownScriptParam() {
return shutdownScriptParam;
}
public String getJavaExecutableFile() {
return javaExecutableFile;
}
public String getServerUrl() {
return serverUrl;
}
public int getServerPort() {
return serverPort;
}
}